home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / dev / c / curses_2_00.lha / curses.doc next >
Text File  |  1992-06-30  |  23KB  |  802 lines
  1.             AMIGA CURSES PACKAGE V2.00
  2.             ==========================
  3.  
  4. Author : Simon John Raybould    (sie@fulcrum.co.uk)
  5. Date   : 20th June 1992
  6.  
  7.  
  8. Version
  9. =======
  10.  
  11. $Id: curses.doc,v 1.3 92/06/29 22:33:08 sie Exp $
  12.  
  13.  
  14. Modification History
  15. ====================
  16.  
  17. $Log:    curses.doc,v $
  18. Revision 1.3  92/06/29  22:33:08  sie
  19. Added some more function descriptions.
  20.  
  21. Revision 1.2  92/06/23  22:38:14  sie
  22. Documentation for amiga curses library.
  23.  
  24.  
  25.  
  26. Description
  27. ===========
  28.  
  29. Version 2.00 and above now support ANSI sequences to allow curses
  30. applications to be executes through the serial port to a terminal or
  31. over a modem to a terminal or terminal package such as "Term20" or
  32. "jrcomm". To enable this, simply set the environment variable
  33. "cursestype" to "ansi" before running the program. If this variable is
  34. not set, curses will open a custom screen.
  35.  
  36. The default number of colours for the custom screen is now 2 (black
  37. and white). To enable 8 colours, call start_color() before initscr().
  38. has_colors() will return TRUE if start_color() has been called else it
  39. will return FALSE.
  40.  
  41.  
  42.  
  43.  
  44. Short descriptions of functions provided
  45. ========================================
  46.  
  47. int initscr(void)
  48.  
  49.     This must be called before any window can be created or
  50.     manipulated. It creates "stdscr" and "curscr". curscr is a copy of
  51.     what curses thinks is currently on the display. Calling
  52.     wrefresh(curscr) will redraw the entire screen and is useful for
  53.     noisy modem lines. This is usually called when the user types ^L
  54.     or sometimes ^R in older programs.
  55.  
  56.     Return value
  57.     ============
  58.     On Success, OK is returned.
  59.     On error, ERR is returned
  60.  
  61.  
  62. int endwin(void)
  63.  
  64.     This should be called before exiting a curses program.
  65.     It frees all memory used and dismantles all structures.
  66.     It closes the custom screen and window used if curses is used in
  67.     non-ANSI mode.
  68.  
  69.     Return value
  70.     ============
  71.     On Success, OK is returned.
  72.     On error, ERR is returned
  73.  
  74.  
  75. int beep(void)
  76.  
  77.     Produces an audible beep from the speaker. This beep is similar in pitch
  78.     and duration to the beep from a terminal when a BEL (^G) character is
  79.     received. If curses is running in ANSI mode, a BEL character will
  80.     be sent to the terminal.
  81.  
  82.     Return value
  83.     ============
  84.     On Success, OK is returned.
  85.     On error, ERR is returned
  86.  
  87.  
  88. int flash(void)
  89.  
  90.     Flashes the display by complementing the background colour. With the
  91.     default black background, this will flash the screen yellow. If
  92.     curses is being used in ANSI mode, a BEL character will be sent to
  93.     the terminal.
  94.  
  95.     Return value
  96.     ============
  97.     On Success, OK is returned.
  98.     On error, ERR is returned
  99.  
  100.  
  101. int baudrate(void)
  102.  
  103.     Returns current baudrate. On the Amiga, it just returns 19200. It is
  104.     used to decide how much to refresh over slow serial lines such as
  105.     modems.
  106.  
  107.     Return value
  108.     ============
  109.     19200 is returned.
  110.  
  111.  
  112. int box(WINDOW *win, char vert, char hor)
  113.  
  114.     Draws a box around the INSIDE edge of the window.
  115.     win   - pointer returned from newwin or subwin, or stdscr even.
  116.     vert  - character to use for the vertical.
  117.     hor   - character to use for the horizontal.
  118.  
  119.     Either of the characters may be zero. In this case, the defaults of
  120.     "|" and "-" will be used for vertical and horizontal respectively.
  121.  
  122.     NOTE
  123.     ----
  124.     The box drawn is INSIDE the window. Therefore any of the clear routines
  125.     will effect the box if carried out on its window. The normal thing
  126.     to do is open two windows, one for the box two columns wider and
  127.     two lines higher than the window for the text. Then use the inner
  128.     window for the text. This way the box is only drawn once.
  129.  
  130.     Return value
  131.     ============
  132.     On Success, OK is returned.
  133.     On error, ERR is returned
  134.  
  135.  
  136. int cbreak(void)
  137. int nocbreak(void)
  138.  
  139.     cbreak() puts the terminal into CBREAK mode, making characters typed
  140.     available immediately.
  141.  
  142.     nocbreak() sets NOCBREAK mode and characters are not available until
  143.     carriage return is pressed.
  144.  
  145.     The default is NOCBREAK mode, so most programs call cbreak() before
  146.     doing any reads on the keyboard for interactive use.
  147.  
  148.     Return value
  149.     ============
  150.     On Success, OK is returned.
  151.     On error, ERR is returned
  152.  
  153.  
  154. int crmode(void)
  155. int nocrmode(void)
  156.  
  157.     As cbreak() and nocbreak() as shown above.
  158.  
  159.     Return value
  160.     ============
  161.     On Success, OK is returned.
  162.     On error, ERR is returned
  163.  
  164.  
  165. int clearok(WINDOW *win, int flag)
  166.  
  167.     If flag is TRUE then it is OK to clear the window on the next refresh.
  168.  
  169.     Return value
  170.     ============
  171.     On Success, OK is returned.
  172.     On error, ERR is returned
  173.  
  174.  
  175. int leaveok(WINDOW *win, int flag)
  176.  
  177.     If flag is TRUE then curses doesn"t care where it leaves the
  178.     cursor. If possible, the cursor will not be displayed.
  179.     The default is FALSE and the cursor is displayed correctly.
  180.  
  181.     Return value
  182.     ============
  183.     On Success, OK is returned.
  184.     On error, ERR is returned
  185.  
  186.  
  187. WINDOW *subwin(WINDOW *orig, int lines, int cols, int beg_line, int beg_col)
  188.  
  189.     Creates a new window within another window. The original window has
  190.     its pointer passed as "orig".
  191.     The new window will be at line "beg_line" and column "beg_col" of the
  192.     window pointed to by "orig". It will be of size "lines" lines of "cols"
  193.     columns.
  194.  
  195.     A sub-window is part of its surrounding window. When the surrounding
  196.     window is refreshed, the sub-window is refreshed as well.
  197.  
  198.     Return value
  199.     ============
  200.     On success, a pointer to a new window is returned.
  201.     On failure, a NULL pointer is returned.
  202.  
  203.  
  204. WINDOW *newwin(int lines, int cols, int beg_line, int beg_col)
  205.  
  206.     Creates a new window at line "beg_line" and column "beg_col",
  207.     "lines" high by "cols" wide.
  208.  
  209.     The new window has its own data structures and does not affect any
  210.     data in other windows. It is only refreshed by a call like
  211.     wrefresh(win) where "win" was returned by this function.
  212.  
  213.     Return value
  214.     ============
  215.     On success, a pointer to a new window is returned.
  216.     On failure, a NULL pointer is returned.
  217.  
  218.  
  219. int delwin(WINDOW *win)
  220.  
  221.     Deletes a window and frees the associated memory. This should be done if
  222.     the window is no longer used.
  223.  
  224.     It is not necessary to free all windows, endwin() will free all windows
  225.     still allocated before returning.
  226.  
  227.     Return value
  228.     ============
  229.     On Success, OK is returned.
  230.     On error, ERR is returned
  231.  
  232.  
  233. int mvwin(WINDOW *win, int new_line, int new_col)
  234.  
  235.     Moves a window to a new position on the screen. This position is relative
  236.     to the top left of the screen and NOT to the start of any surrounding
  237.     window in the case of sub-windows.
  238.  
  239.     Return value
  240.     ============
  241.     On Success, OK is returned.
  242.     On error, ERR is returned
  243.  
  244.  
  245. int nl(void)
  246. int nonl(void)
  247.  
  248.     nl() - Causes newline to newline/carriage return mapping on output and
  249.     return to newline mapping on input.
  250.  
  251.     nonl() - disables this.
  252.     The DEFAULT is that mapping is done (nl).
  253.  
  254.     Return value
  255.     ============
  256.     On Success, OK is returned.
  257.     On error, ERR is returned
  258.  
  259.  
  260. int echo(void)
  261. int noecho(void)
  262.  
  263.     echo() causes characters read from the keyboard to be echoed to the
  264.     display. noecho() prevents the echo, this is useful when reading
  265.     keys that you don"t want echoed to the screen.
  266.     The DEFAULT is that echoing is performed (echo).
  267.  
  268.     Return value
  269.     ============
  270.     On Success, OK is returned.
  271.     On error, ERR is returned
  272.  
  273.  
  274. int nodelay(WINDOW *win, int flag)
  275.  
  276.     nodelay() sets nodelay mode if "flag" is TRUE.  When in nodelay mode,
  277.     getch() will return ERR if there is no input pending.  The DEFAULT is
  278.     nodelay not set and getch() will block, waiting for at least one char
  279.     in CBREAK mode or a line followed by carriage return in non CBREAK
  280.     mode.
  281.  
  282.     Return value
  283.     ============
  284.     On Success, OK is returned.
  285.     On error, ERR is returned
  286.  
  287.  
  288. int has_colors(void)
  289. int start_color(void)
  290. int init_color(int n, int r, int g, int b) 
  291.  
  292.     has_colors() is to check if colours are available on this terminal.
  293.     On the Amiga, it will return TRUE if start_color() has been called
  294.     else it will return FALSE.
  295.  
  296.     start_colour() is to tell the terminal that you wish to use colour. In
  297.     Amiga curses, this MUST be called before initscr() or it will have no
  298.     effect because initscr() sets up the screen and needs to know how many
  299.     colours you want.
  300.  
  301.     init_color() will alter the Red, Green and Blue content of colour n.
  302.     r, g and b are in the range 1 to 1000. The colour number "n" is in the
  303.     range 0 to 15 and it should be noted that colour 0 is the background
  304.     colour. Initially the foreground is set to colour 1 but can be changed
  305.     with the attron() or attrset() function to any of the colours 1 to 15,
  306.     0 is not allowed as this is the background. If 0 is selected, the
  307.     foreground colour will be set to 1.
  308.  
  309.     Return value
  310.     ============
  311.     On Success, OK is returned.
  312.     On error, ERR is returned
  313.  
  314.  
  315. int keypad(WINDOW *win, int flag)
  316.  
  317.     If "flag" is TRUE then the ANSI sequences for the function keys and
  318.     the cursor keys will be converted to the tokens KEY_UP, KEY_HELP,
  319.     e.t.c.  The DEFAULT is that the ANSI sequences will returned.  So to
  320.     cause special keys to be returned as tokens in the standard screen,
  321.     add the following line:
  322.  
  323.         keypad(stdscr, TRUE);
  324.  
  325.     Return value
  326.     ============
  327.     On Success, OK is returned.
  328.     On error, ERR is returned
  329.  
  330.  
  331. int printw(char *fmt, ...)
  332. int wprintw(WINDOW *win, char *fmt, ...)
  333. int mvprintw(int line, int col, char *fmt, ...)
  334. int mvwprintw(WINDOW *win, int line, int col, char *fmt, ...)
  335.  
  336.     Produce formatted output similar to printf(3).
  337.     printw() - prints at the current position in stdscr.
  338.     wprintw() - prints at the current position in win.
  339.     mvprintw() - prints at line "line" column "col" in stdscr.
  340.     mvwprintw() - prints at line "line" column "col" in "win".
  341.  
  342.     Return value
  343.     ============
  344.     On Success, number of formats successfully replaced is returned.
  345.     On error, -1 is returned.
  346.  
  347.  
  348. scanw(char *fmt, ...)
  349. wscanw(WINDOW *win, char *fmt, ...)
  350. mvscanw(int line, int col, char *fmt, ...)
  351. mvwscanw(WINDOW *win, int line, int col, char *fmt, ...)
  352.  
  353.     Produce formatted input similar to scanf(3).
  354.     scanw() - scans at the current position in stdscr.
  355.     wscanw() - scans at the current position in win.
  356.     mvscanw() - scans at line "line" column "col" in stdscr.
  357.     mvwscanw() - scans at line "line" column "col" in "win".
  358.  
  359.     Return value
  360.     ============
  361.     On Success, number of formats successfully replaced is returned.
  362.     On error, -1 is returned.
  363.  
  364.  
  365. int scrollok(WINDOW *win, int flag)
  366.  
  367.     When flag is true, curses will automatically scroll the window up one
  368.     line when output goes off the bottom of "win".
  369.     E.g.
  370.             scrollok(stdscr, TRUE);
  371.     
  372.     "stdscr" will then be automatically scrolled up one line when output goes
  373.     off bottom.
  374.     The DEFAULT is that the window will NOT be scrolled, the bottom line
  375.     will be used over and over again without scrolling.
  376.  
  377.     Return value
  378.     ============
  379.     On Success, OK is returned.
  380.     On error, ERR is returned
  381.  
  382.  
  383. int scroll(WINDOW *win)
  384.  
  385.     The window "win" is scrolled up one line.
  386.  
  387.     Return value
  388.     ============
  389.     On Success, OK is returned.
  390.     On error, ERR is returned
  391.  
  392.  
  393. int setscrreg(int top, int bottom)
  394. int wsetscrreg(WINDOW *win, int top, int bottom)
  395.  
  396.     Sets the scrolling region from line "top" to line "bottom" inclusive.
  397.     Only the region between these two lines is scrolled when scroll() is
  398.     called or when output moves off the end of line "bottom", the region
  399.     is scrolled up one line (if scrollok() has been called).
  400.  
  401.     Return value
  402.     ============
  403.     On Success, OK is returned.
  404.     On error, ERR is returned
  405.  
  406.  
  407. int touchwin(WINDOW *win)
  408.  
  409.     Will force the window to be completely refreshed on the next call to
  410.     refresh() by dumping all optimization information. This can be useful if
  411.     the state of the screen is unknown or if a window was obscured by
  412.     another window which was not a subwindow of the one it covered. Then
  413.     you may need to touchwin() the window that was covered and refresh it.
  414.  
  415.     If you have several windows and wish to redraw the entire display,
  416.     such as when ^L is pressed in many applications, you could touchwin
  417.     all of your windows, clear the screen and refresh each one in turn.
  418.     The recommended way to do this however is to simply wrefresh(curscr).
  419.  
  420.     Return value
  421.     ============
  422.     On Success, OK is returned.
  423.     On error, ERR is returned
  424.  
  425.  
  426. int addch(char c)
  427. int waddch(WINDOW *win, char c)
  428. int mvaddch(int int line, int col, char c)
  429. int mvwaddch(WINDOW *win, int line, int col, char c)
  430.  
  431.     addch(c) - Prints character "c" at current screen position in "stdscr".
  432.  
  433.     waddch(win, c) - Prints character "c" at current screen position in "win".
  434.  
  435.     mvaddch(line, col, c) - Prints character "c" at line "line" column "col" in
  436.             "stdscr".
  437.  
  438.     mvwaddch(win, line, col, c) - Prints character "c" at line "line" column
  439.             "col" in win.
  440.  
  441.     Return value
  442.     ============
  443.     On Success, OK is returned.
  444.     On error, ERR is returned
  445.  
  446.  
  447. int addstr(char *str)
  448. int waddstr(WINDOW *win, char *str)
  449. int mvaddstr(int line, int col, char *str)
  450. int mvwaddstr(WINDOW *win, int line, int col, char *str)
  451.  
  452.     addstr(str) - Prints string "str" at the current screen position in "stdscr".
  453.  
  454.     waddstr(win, str) - Prints string "str" at current screen position in "win".
  455.  
  456.     mvaddstr(line, col, str) - Prints string "str" at line "line" column "col"
  457.             in "stdscr".
  458.  
  459.     mvwaddstr(win, line, col, str) - Prints string "str" at line "line"
  460.               column "col" in window "win".
  461.  
  462.     Return value
  463.     ============
  464.     On Success, OK is returned.
  465.     On error, ERR is returned
  466.  
  467.  
  468. int attrset(UBYTE attrs)
  469. int wattrset(WINDOW *win, UBYTE attrs)
  470.  
  471.     These routines set the attributes for "stdscr" or the specified window
  472.     (in the case of wattrset()) to the value specified in "attrs". This is
  473.     usually used to get the attributes to a known state before using
  474.     attron() and attroff() to add and remove extra attributes
  475.     respectively. The danger is that all previous attributes are lost and
  476.     replaced by the new ones. Consequently they are not really necessary.
  477.  
  478.     See attron() and attroff().
  479.  
  480.     Return value
  481.     ============
  482.     On Success, OK is returned.
  483.     On error, ERR is returned
  484.  
  485.  
  486. int attron(UBYTE attrs)
  487. int wattron(WINDOW *win, UBYTE attrs)
  488.  
  489.     These routines add the attributes specified in "attrs" to those
  490.     already set for "stdscr" or the window specified (in the case of
  491.     wattron()). Any previous attributes that are not directly affected by
  492.     the changes will be left as they were. This is the preferred way to
  493.     set and unset attributes as it has no effect on other attributes.
  494.  
  495.     Return value
  496.     ============
  497.     On Success, OK is returned.
  498.     On error, ERR is returned
  499.  
  500.  
  501. int attroff(UBYTE attrs)
  502. int wattroff(WINDOW *win, UBYTE attrs)
  503.  
  504.     These routines remove the attributes specified in attrs from those set
  505.     for stdscr or the window specified in the case of wattroff().  Any
  506.     previous attributes that are not directly affected by the changes will
  507.     be left as they were.  This is the preferred method of resetting
  508.     attributes rather than calling attrset.
  509.  
  510.     Example:
  511.  
  512.         attron(A_REVERSE)
  513.         addstr("This is in inverse");
  514.         attroff(A_REVERSE);
  515.         refresh();
  516.  
  517.     Return value
  518.     ============
  519.     On Success, OK is returned.
  520.     On error, ERR is returned
  521.  
  522.  
  523. int standout(void)
  524. int wstandout(WINDOW *win)
  525. int standend(void)
  526. int wstandend(WINDOW *win)
  527.  
  528.     These routines set and reset inverse video mode.
  529.  
  530.     Example
  531.     =======
  532.  
  533.     standout();
  534.     addstr("This is inverse video");
  535.     standend();
  536.     addstr("This is normal video");
  537.     refresh();
  538.  
  539.     Return value
  540.     ============
  541.     On Success, OK is returned.
  542.     On error, ERR is returned
  543.  
  544.  
  545. int erase(void)
  546. int werase(WINDOW *win)
  547.  
  548.     These routines will empty the screen buffer and will cause the screen
  549.     to be cleared on the next call to refresh().
  550.  
  551.     Return value
  552.     ============
  553.     On Success, OK is returned.
  554.     On error, ERR is returned
  555.  
  556.  
  557. int clear(void)
  558. int wclear(WINDOW *win)
  559.  
  560.     These routines will empty the screen buffer and will cause the screen
  561.     to be cleared on the next call to refresh(). Similar to erase() except
  562.     that these will call clearok() as well. If possible, a clear sequence
  563.     will be sent to the screen whereas erase() just fills the buffer with
  564.     spaces.
  565.  
  566.     Return value
  567.     ============
  568.     On Success, OK is returned.
  569.     On error, ERR is returned
  570.  
  571.  
  572. int clrtobot(void)
  573. int wclrtobot(WINDOW *win)
  574.  
  575.     On the next call to refresh(), the window will be cleared from the
  576.     current position to bottom righthand corner.
  577.  
  578.     Return value
  579.     ============
  580.     On Success, OK is returned.
  581.     On error, ERR is returned
  582.  
  583.  
  584. int clrtoeol(void)
  585. int wclrtoeol(win)
  586.  
  587.     On the next call to refresh(), the window will be cleared from the
  588.     current position to the end of the line.
  589.  
  590.     Return value
  591.     ============
  592.     On Success, OK is returned.
  593.     On error, ERR is returned
  594.  
  595.  
  596. int delch(void)
  597. int wdelch(WINDOW *win)
  598. int mvdelch(int line, int col)
  599. int mvwdelch(WINDOW *win, int line, int col)
  600.  
  601.     These routines delete the character at the current position, the rest
  602.     of the line to the right of this character is slid along to the left
  603.     to fill the gap. This can be very useful in editors and the like.
  604.  
  605.     Return value
  606.     ============
  607.     On Success, OK is returned.
  608.     On error, ERR is returned
  609.  
  610.  
  611. int getch(void)
  612. int wgetch(WINDOW *win)
  613. int mvgetch(int line, int col)
  614. int mvwgetch(WINDOW *win, int line, int col)
  615.  
  616.     These routines return the next character from the keyboard. If
  617.     cbreak() has been called then they return as soon as there is a
  618.     character to read else they wait for a <CR> before returning. If
  619.     nodelay() has been called then they will return a character if there
  620.     is one or ERR if not.
  621.  
  622.     Return value
  623.     ============
  624.     On Success, the character read is returned.
  625.     On error, ERR is returned
  626.  
  627.  
  628. int getstr(void)
  629. int wgetstr(WINDOW *win)
  630. int mvgetstr(int line, int col)
  631. int mvwgetstr(WINDOW *win, int line, int col)
  632.  
  633.     These routines should be used to read a string in from the keyboard.
  634.     Delete is processed for you.
  635.  
  636.     Return value
  637.     ============
  638.     On Success, OK is returned.
  639.     On error, ERR is returned
  640.  
  641.  
  642. int inch(void)
  643. int winch(WINDOW *win)
  644. int mvinch(int line, int col)
  645. int mvwinch(WINDOW *win, int line, int col)
  646.  
  647.     These routines return the character at the current position in the
  648.     window or stdscr if the window is not required.
  649.     The routines that take a line and column move the cursor to that
  650.     position in the window and then return the char at that position.
  651.  
  652.     Return value
  653.     ============
  654.     On Success, OK is returned.
  655.     On error, ERR is returned
  656.  
  657.  
  658. int insch(void)
  659. int winsch(WINDOW *win)
  660. int mvinsch(int line, int col)
  661. int mvwinsch(WINDOW *win, int line, int col)
  662.  
  663.     These routines insert a character at the current window position, or at
  664.     the specified position in the "mv" cases. The remainder of the line is
  665.     shifted along to the right to make room. The character at the far right
  666.     is lost.
  667.  
  668.     Return value
  669.     ============
  670.     On Success, OK is returned.
  671.     On error, ERR is returned
  672.  
  673.  
  674. int insertln(void)
  675. int winsterln(WINDOW *win)
  676.  
  677.     These routines insert one line at the current window position.
  678.     All of the lines below are shifted down and the bottom line is lost.
  679.  
  680.     Return value
  681.     ============
  682.     On Success, OK is returned.
  683.     On error, ERR is returned
  684.  
  685.  
  686. int deleteln(void)
  687. int wdeleteln(WINDOW *win)
  688.  
  689.     These routines delete one line at the current window position.
  690.     All of the lines below are shifted up into the space and the bottom line
  691.     is left blank.
  692.  
  693.     Return value
  694.     ============
  695.     On Success, OK is returned.
  696.     On error, ERR is returned
  697.  
  698.  
  699. int move(int line, int col)
  700. int wmove(WINDOW *win, int line, int col)
  701.  
  702.     These routines set the current coordinates to "line" and "col". The
  703.     next text added to this window will then go at this position.
  704.  
  705.     Return value
  706.     ============
  707.     On Success, OK is returned.
  708.     On error, ERR is returned
  709.  
  710.  
  711. int refresh(void)
  712. int wrefresh(WINDOW *win)
  713.  
  714.     refresh() will cause all outstanding characters for stdscr to be sent.
  715.     wrefresh() will do the same a refresh but on the window specified.
  716.  
  717.     Return value
  718.     ============
  719.     On Success, OK is returned.
  720.     On error, ERR is returned
  721.  
  722.  
  723. int wnoutrefresh(WINDOW *win)
  724. int doupdate(void)
  725.  
  726.     Will cause "win" to be refreshed when doupdate() is next called.
  727.     You can then wnoutrefresh() several windows and make one call to
  728.     doupdate() to do all the updates at once.
  729.  
  730.     Return value
  731.     ============
  732.     On Success, OK is returned.
  733.     On error, ERR is returned
  734.  
  735.  
  736. int fixterm(void)
  737.  
  738.     This function does nothing on the Amiga, it is provided to allow
  739.     programs that use it to link without trouble.
  740.  
  741.     Return value
  742.     ============
  743.     OK is returned.
  744.  
  745.  
  746. int flushinp(void)
  747.  
  748.     This function empties the keyboard buffer. It will trash all
  749.     characters that have been buffered up.
  750.  
  751.     Return value
  752.     ============
  753.     OK is returned.
  754.  
  755.  
  756. int idlok(WINDOW *WinPtr, int flag)
  757.  
  758.     This fuction enables hardware insert & delete line. This does not
  759.     currently have any effect.
  760.  
  761.     Return value
  762.     ============
  763.     OK is returned.
  764.  
  765.  
  766. int saveterm(void)
  767. int resetterm(void)
  768.  
  769.     saveterm() saves the current terminal settings and resetterm() resets
  770.     the terminal to the state it was in when the last save was done. On
  771.     the Amiga, they have no effect.
  772.  
  773.     Return value
  774.     ============
  775.     OK is returned.
  776.  
  777.  
  778. int savetty(void)
  779. int resetty(void)
  780.  
  781.     savetty() saves the current terminal settings and resettty() resets
  782.     the terminal to the state it was in when the last save was done. On
  783.     the Amiga, they have no effect.
  784.  
  785.     Return value
  786.     ============
  787.     OK is returned.
  788.  
  789.  
  790. int mvcur(int oldline, int oldcol, int newline, int newcol)
  791.  
  792.     This will move the cursor to the position specified by "newline" and
  793.     "newcol". The move is immediate and so refresh() does not need to be
  794.     called, in fact a call to refresh() will cause the cursor to be moved
  795.     after the last char printed during that refresh.
  796.     oldline and oldcol are currently ignored.
  797.  
  798.     Return value
  799.     ============
  800.     On Success, OK is returned.
  801.     On error, ERR is returned
  802.